{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Quantum edge detection\n",
    "\n",
    "Image processing allows us to understand what is occurring in an image, and edge detection is an essential method to identify components of an image. Edge detection is the process of detecting edges of components to distinguish them by their perimeter. In this tutorial, we will use Quantum Hadamard Edge detection (QHED) to perform edge detection [1](https://arxiv.org/pdf/2404.06889).\n",
    "\n",
    "To perform quantum image processing on images used with classical image processing, we need to convert them to quantum images. There are various types of quantum image representation. In this tutorial, we will introduce the Quantum Probability Image Encoding (QPIE) and the Flexible Representation of Quantum Images (FRQI). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "import cudaq\n",
    "import numpy as np\n",
    "import cupy as cp\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib import style\n",
    "style.use('bmh')\n",
    "\n",
    "cudaq.set_target(\"nvidia\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Image "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "image = np.array([[0, 0, 0, 0, 0, 0, 0, 0],\n",
    "                  [0, 1, 1, 1, 1, 1, 0, 0],\n",
    "                  [0, 1, 1, 1, 1, 1, 1, 0],\n",
    "                  [0, 1, 1, 1, 1, 1, 1, 0],\n",
    "                  [0, 1, 1, 1, 1, 1, 1, 0],\n",
    "                  [0, 0, 0, 1, 1, 1, 1, 0],\n",
    "                  [0, 0, 0, 1, 1, 1, 1, 0],\n",
    "                  [0, 0, 0, 0, 0, 0, 0, 0]])\n",
    "\n",
    "def plot_image(img, title: str):\n",
    "    plt.title(title)\n",
    "    plt.xticks(range(img.shape[0]))\n",
    "    plt.yticks(range(img.shape[1]))\n",
    "    plt.imshow(img, extent=[0, img.shape[0], img.shape[1], 0], cmap='viridis')\n",
    "    plt.show()\n",
    "\n",
    "plot_image(image, 'Original Image')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Quantum Probability Image Encoding (QPIE):\n",
    "\n",
    "Lets take as an example a classical 2x2 image (4 pixels). We can label each pixel with its position\n",
    "\n",
    "<div>\n",
    "<img src=\"images/pixels-img.png\" width=\"200\">\n",
    "</div>\n",
    "\n",
    "Each pixel will have its own color intensity represented along with its position label as an 8-bit black and white color. To convert the pixel intensity to probability amplitudes of a quantum state\n",
    "\n",
    "$$ c_i = \\frac{I_{yx}}{\\sqrt(\\sum I^2_{yx})} $$\n",
    "\n",
    "The state can now be written as:\n",
    "\n",
    "$$ \\ket{img} = c_0 \\ket{00} + c_1 \\ket{01} + c_2 \\ket{10} + c_3 \\ket{11}$$\n",
    "\n",
    "\n",
    "### Below we show how to encode an image using QPIE in cudaq.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "length of the horizontal state:  (64,)\n",
      "length of the vertical state:  (64,)\n"
     ]
    }
   ],
   "source": [
    "def amplitude_encode(img_data):\n",
    "    # Convert the input data to a CuPy array\n",
    "    img_data = cp.array(img_data)\n",
    "    \n",
    "    # Calculate the RMS value\n",
    "    rms = cp.sqrt(cp.sum(cp.sum(img_data**2, axis=1)))\n",
    "    \n",
    "    # Create normalized image\n",
    "    image_norm = img_data / rms\n",
    "    \n",
    "    # Flatten the normalized image to a one-dimensional array\n",
    "    image_norm_flat = image_norm.flatten()\n",
    "    \n",
    "    # Return the normalized image as a CuPy array with complex data type\n",
    "    return image_norm_flat.astype(cp.complex64)\n",
    "\n",
    "# Get the amplitude ancoded pixel values\n",
    "\n",
    "# Horizontal: Original image\n",
    "image_norm_h = amplitude_encode(image)\n",
    "print('length of the horizontal state: ', image_norm_h.shape)\n",
    "state_image_h = cudaq.State.from_data(image_norm_h)\n",
    "\n",
    "# Vertical: Transpose of Original image\n",
    "image_norm_v = amplitude_encode(image.T)\n",
    "print('length of the vertical state: ', image_norm_v.shape)\n",
    "state_image_v = cudaq.State.from_data(image_norm_v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Flexible Representation of Quantum Images (FRQI):\n",
    "\n",
    "Here, we encode the pixel data in angles, which requires only one qubit to store pixel information $\\ket{c_i}$, and the rest of the qubits stores position $\\ket{i}$ information. \n",
    "\n",
    "The gray value information of the pixels is encoded by\n",
    "$$ \\ket{c_i} =  \\mathrm{cos}(\\theta_i) \\ket{0} + \\mathrm{sin}(\\theta_i) \\ket{1} $$\n",
    "\n",
    "where $\\theta = (\\theta_0, \\theta_1, \\theta_2, ...)$ is a vector of angles encoding the gray values of each pixel. The FRQI state is then given by\n",
    "\n",
    "$$ \\ket{img(\\theta)} = \\frac{1}{2^n} \\sum_{i=0}^{2^{2n}-1}  \\ket{c_i}  \\ket{i}$$\n",
    "\n",
    "\n",
    "To learn more about the FRQI representation, see [1](https://link.springer.com/article/10.1007/s11128-010-0177-y), [2](https://arxiv.org/pdf/2110.15672).\n",
    "\n",
    "### Building the FRQI State:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of qubits: 6\n",
      "Angles: [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.5707963267948966, 1.5707963267948966, 1.5707963267948966, 1.5707963267948966, 1.5707963267948966, 0.0, 0.0, 0.0, 1.5707963267948966, 1.5707963267948966, 1.5707963267948966, 1.5707963267948966, 1.5707963267948966, 1.5707963267948966, 0.0, 0.0, 1.5707963267948966, 1.5707963267948966, 1.5707963267948966, 1.5707963267948966, 1.5707963267948966, 1.5707963267948966, 0.0, 0.0, 1.5707963267948966, 1.5707963267948966, 1.5707963267948966, 1.5707963267948966, 1.5707963267948966, 1.5707963267948966, 0.0, 0.0, 0.0, 0.0, 1.5707963267948966, 1.5707963267948966, 1.5707963267948966, 1.5707963267948966, 0.0, 0.0, 0.0, 0.0, 1.5707963267948966, 1.5707963267948966, 1.5707963267948966, 1.5707963267948966, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]\n",
      "Length of angles: 64\n"
     ]
    }
   ],
   "source": [
    "def frqi(image):\n",
    "    \n",
    "    faltten_image = image.flatten()\n",
    "    angles=[]\n",
    "    for intensity in faltten_image:\n",
    "        if intensity == 0:\n",
    "            angles.append(0.0)\n",
    "        else:\n",
    "            theta = np.arcsin(intensity)\n",
    "            angles.append(theta)\n",
    "\n",
    "    # number of qubits\n",
    "    pos_pixel = int(np.log2(len(angles)))\n",
    "\n",
    "    k_value = pos_pixel-1\n",
    "\n",
    "    # This function let us know which are the qubits that need to be applied  \n",
    "    # the X-gate so we can change the state of the pixels positions qubits\n",
    "    # to the new state.\n",
    "\n",
    "    def change(state, new_state):\n",
    "        \n",
    "        n = len(state)  # n is the length of the binary string\n",
    "        c = np.array([])  # create an empty array\n",
    "        for i in range(n):  # start to iterate n times\n",
    "            if state[i] != new_state[i]:               \n",
    "                c = np.append(c, int(i))  # if it is different we append the position to the array\n",
    "                \n",
    "        if len(c) > 0:\n",
    "            return c.astype(int)\n",
    "        else:\n",
    "            return c\n",
    "\n",
    "    index=[]\n",
    "\n",
    "    for jk in range(len(angles)):\n",
    "        state = '{0:0{1}b}'.format(jk-1, pos_pixel)\n",
    "        new_state = '{0:0{1}b}'.format(jk, pos_pixel)\n",
    "        \n",
    "        if jk != 0:\n",
    "            c = change(state, new_state)\n",
    "            if len(c) > 0:\n",
    "                temp = np.abs(c-k_value)\n",
    "                index.append(temp)\n",
    "\n",
    "    index_q = []\n",
    "    num_x = []\n",
    "\n",
    "    for arr in index:\n",
    "        count = 0\n",
    "        arr = arr.tolist()\n",
    "        for idx in arr:\n",
    "            index_q.append(idx)\n",
    "            count += 1\n",
    "        num_x.append(count)\n",
    "    \n",
    "    return angles, index_q, num_x, pos_pixel\n",
    "\n",
    "angles, index_q, num_x, pos_pixel = frqi(image)\n",
    "\n",
    "print('Number of qubits:', pos_pixel)\n",
    "print('Angles:', angles)\n",
    "print('Length of angles:', len(angles))\n",
    "#print('Index:', index_q)\n",
    "#print('Number of X-gates:', num_x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Measurement and Image Retrieval:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "@cudaq.kernel\n",
    "def y_rot(q:cudaq.qubit, theta:float):\n",
    "    ry(2.0*theta, q)\n",
    "\n",
    "@cudaq.kernel\n",
    "def frqi(q_pos:int, angles:list[float], index_q:list[int], num_x:list[int]):\n",
    "    qubits = cudaq.qvector(q_pos)\n",
    "    aux = cudaq.qubit()\n",
    "    \n",
    "    h(qubits)\n",
    "    \n",
    "    j = 0\n",
    "    count = 0\n",
    "    for theta in angles:\n",
    "        if j == 0:\n",
    "            cudaq.control(y_rot, qubits, aux, theta)\n",
    "        else:\n",
    "            tot_x = num_x[j-1]\n",
    "            for i in range(tot_x):\n",
    "                x(qubits[index_q[count]])\n",
    "                count += 1\n",
    "            cudaq.control(y_rot, qubits, aux, theta)\n",
    "        j += 1\n",
    "    \n",
    "    mz(qubits)\n",
    "    mz(aux)\n",
    "            \n",
    "            \n",
    "shots = 1000000    \n",
    "counts = cudaq.sample(frqi, pos_pixel, angles, index_q, num_x, shots_count=shots)\n",
    "#print(counts)\n",
    "\n",
    "total_qubits = pos_pixel+1\n",
    "amp = np.zeros(2**total_qubits)\n",
    "for bit,count in counts.items():\n",
    "    decimal = int(bit[::-1], 2)\n",
    "    amp[decimal] = count/shots\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "retrieved image\n",
      "[[0 0 0 0 0 0 0 0]\n",
      " [0 1 1 1 1 1 0 0]\n",
      " [0 1 1 1 1 1 1 0]\n",
      " [0 1 1 1 1 1 1 0]\n",
      " [0 1 1 1 1 1 1 0]\n",
      " [0 0 0 1 1 1 1 0]\n",
      " [0 0 0 1 1 1 1 0]\n",
      " [0 0 0 0 0 0 0 0]]\n"
     ]
    }
   ],
   "source": [
    "# Create an empty array to save the retrieved image\n",
    "\n",
    "retrieve_image = np.array([])\n",
    "\n",
    "#print(retrieve_image.shape)\n",
    "\n",
    "for i in range(len(angles)):\n",
    "    s = format(i, '06b')\n",
    "    #print(s)\n",
    "    s_1 = '1' + s\n",
    "    decimal_1 = int(s_1,2)\n",
    "    s_0 = '0' + s\n",
    "    decimal_0 = int(s_0, 2)\n",
    "    \n",
    "    pixel_value = np.arccos(np.sqrt(amp[decimal_0]/(amp[decimal_1]+amp[decimal_0])))\n",
    "    \n",
    "    if pixel_value > 0.0:\n",
    "        retrieve_image = np.append(retrieve_image, pixel_value)\n",
    "    else:\n",
    "        retrieve_image = np.append(retrieve_image, [0.0])\n",
    "    \n",
    "#print(retrieve_image)\n",
    "#print(retrieve_image.shape)\n",
    "\n",
    "retrieve_image *= (2.0/np.pi)\n",
    "\n",
    "# Turn the array into a type int\n",
    "retrieve_image = retrieve_image.astype('int')\n",
    "\n",
    "x = int(np.sqrt(len(angles)))\n",
    "retrieve_image = retrieve_image.reshape((x,x))\n",
    "print('retrieved image')\n",
    "print(retrieve_image)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Quantum Hadamard Edge Detection (QHED)\n",
    "\n",
    "Classically, to determine the edge of an image, we need to determine the pixel-intensity gradients. This requires processing each pixel, which leads to a complexity of O(N) for an image of N pixels. Since pixel number grows exponentially with image size, this poses a problem for large images.\n",
    "\n",
    "With a quantum algorithm, we can determine the pixel-intensity gradients with complexity O(1), regardless of the image size, by taking advantage of the superposition induced by the Hadamard gate. This is an exponential speedup. Furthermore, we only need n qubits for an image with $2^n$ pixels.\n",
    "\n",
    "Below, we show how to implement the QHED along with some classical post-processing to get our edge detected horizontal and vertical scans. We employ in this example QPIE to encode the image."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     ╭───╮╭───╮                              ╭───╮\n",
      "q0 : ┤ h ├┤ x ├──●────●────●────●────●────●──┤ h ├\n",
      "     ╰───╯╰───╯╭─┴─╮  │    │    │    │    │  ╰───╯\n",
      "q1 : ──────────┤ x ├──●────●────●────●────●───────\n",
      "               ╰───╯╭─┴─╮  │    │    │    │       \n",
      "q2 : ───────────────┤ x ├──●────●────●────●───────\n",
      "                    ╰───╯╭─┴─╮  │    │    │       \n",
      "q3 : ────────────────────┤ x ├──●────●────●───────\n",
      "                         ╰───╯╭─┴─╮  │    │       \n",
      "q4 : ─────────────────────────┤ x ├──●────●───────\n",
      "                              ╰───╯╭─┴─╮  │       \n",
      "q5 : ──────────────────────────────┤ x ├──●───────\n",
      "                                   ╰───╯╭─┴─╮     \n",
      "q6 : ───────────────────────────────────┤ x ├─────\n",
      "                                        ╰───╯     \n",
      "\n"
     ]
    }
   ],
   "source": [
    "qubits_num= int(np.log2(image_norm_h.shape[0]))\n",
    "total_qubits = qubits_num + 1\n",
    "\n",
    "@cudaq.kernel\n",
    "def qc_img(vec: cudaq.State):\n",
    "    \n",
    "    ancilla = cudaq.qubit()\n",
    "    qubits = cudaq.qvector(vec)\n",
    "    \n",
    "    qubit_num = qubits.size()\n",
    "    \n",
    "    h(ancilla)\n",
    "\n",
    "    x(ancilla)\n",
    "    x.ctrl(ancilla, qubits[0])\n",
    "    \n",
    "    for i in range(1, qubit_num):\n",
    "        x.ctrl([ancilla, *qubits[0:i]], qubits[i])\n",
    "            \n",
    "    h(ancilla)\n",
    "\n",
    "print(cudaq.draw(qc_img, state_image_h))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Sampling the circuit\n",
    "\n",
    "shots=100000\n",
    "result_h = cudaq.sample(qc_img, state_image_h, shots_count=shots)\n",
    "result_v = cudaq.sample(qc_img, state_image_v, shots_count=shots)\n",
    "\n",
    "amp_h = np.zeros(2**total_qubits)\n",
    "\n",
    "for bit,count in result_h.items():\n",
    "    decimal = int(bit[::-1], 2)\n",
    "    #print(decimal, bit, count/shots)\n",
    "    amp_h[decimal] = count/shots\n",
    "\n",
    "amp_v = np.zeros(2**total_qubits)\n",
    "\n",
    "for bit,count in result_v.items():\n",
    "    decimal = int(bit[::-1], 2)\n",
    "    #print(decimal, bit, count/shots)\n",
    "    amp_v[decimal] = count/shots    \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Post-processing "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "x=int(np.sqrt(image_norm_h.shape[0]))\n",
    "edge_scan_h = np.array([amp_h[2*i+1] for i in range(2**qubits_num)]).reshape(x, x)\n",
    "edge_scan_v = np.array([amp_v[2*i+1] for i in range(2**qubits_num)]).reshape(x, x).T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_image(edge_scan_h, 'Horizontal scan output')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_image(edge_scan_v, 'vertical scan output')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we combine both horizontal and vertical scans to get the complete edge detected image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Combining the horizontal and vertical component of the result\n",
    "edge_scan_sim = edge_scan_h + edge_scan_v\n",
    "\n",
    "plot_image(edge_scan_sim, 'Edge Detected image')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
